import dayjs from 'dayjs'

/**
 * 格式化日期
 * @param {string|Date} date - 日期
 * @param {string} format - 格式化模式
 * @returns {string} 格式化后的日期字符串
 */
export const formatDate = (date, format = 'YYYY-MM-DD HH:mm:ss') => {
  if (!date) return ''
  return dayjs(date).format(format)
}

/**
 * 计算相对时间
 * @param {string|Date} date - 日期
 * @returns {string} 相对时间字符串
 */
export const formatRelativeTime = (date) => {
  if (!date) return ''
  const now = dayjs()
  const target = dayjs(date)
  const diffMinutes = now.diff(target, 'minute')
  const diffHours = now.diff(target, 'hour')
  const diffDays = now.diff(target, 'day')
  
  if (diffMinutes < 1) return '刚刚'
  if (diffMinutes < 60) return `${diffMinutes}分钟前`
  if (diffHours < 24) return `${diffHours}小时前`
  if (diffDays < 30) return `${diffDays}天前`
  
  return formatDate(date, 'YYYY-MM-DD')
}

/**
 * 格式化价格
 * @param {number} price - 价格
 * @param {number} decimals - 小数位数
 * @returns {string} 格式化后的价格
 */
export const formatPrice = (price, decimals = 2) => {
  if (price === null || price === undefined || isNaN(price)) return '0.00'
  return parseFloat(price).toFixed(decimals)
}

/**
 * 格式化数字
 * @param {number} num - 数字
 * @returns {string} 格式化后的数字
 */
export const formatNumber = (num) => {
  if (num === null || num === undefined || isNaN(num)) return '0'
  
  if (num >= 100000000) {
    return (num / 100000000).toFixed(1) + '亿'
  } else if (num >= 10000) {
    return (num / 10000).toFixed(1) + '万'
  } else {
    return num.toString()
  }
}

/**
 * 验证邮箱
 * @param {string} email - 邮箱地址
 * @returns {boolean} 是否有效
 */
export const validateEmail = (email) => {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return emailRegex.test(email)
}

/**
 * 验证手机号
 * @param {string} phone - 手机号
 * @returns {boolean} 是否有效
 */
export const validatePhone = (phone) => {
  const phoneRegex = /^1[3456789]\d{9}$/
  return phoneRegex.test(phone)
}

/**
 * 验证密码强度
 * @param {string} password - 密码
 * @returns {Object} 密码强度信息
 */
export const validatePassword = (password) => {
  let strength = 0
  let message = ''
  let suggestions = []
  
  if (!password) {
    return { strength: 0, message: '密码不能为空', suggestions: ['请输入密码'] }
  }
  
  // 长度检查
  if (password.length >= 8) {
    strength += 1
  } else {
    suggestions.push('密码长度至少8个字符')
  }
  
  // 包含小写字母
  if (/[a-z]/.test(password)) {
    strength += 1
  } else {
    suggestions.push('密码应包含小写字母')
  }
  
  // 包含大写字母
  if (/[A-Z]/.test(password)) {
    strength += 1
  } else {
    suggestions.push('密码应包含大写字母')
  }
  
  // 包含数字
  if (/[0-9]/.test(password)) {
    strength += 1
  } else {
    suggestions.push('密码应包含数字')
  }
  
  // 包含特殊字符
  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
    strength += 1
  } else {
    suggestions.push('密码应包含特殊字符')
  }
  
  // 强度消息
  switch (strength) {
    case 0:
    case 1:
      message = '弱'
      break
    case 2:
    case 3:
      message = '中'
      break
    case 4:
    case 5:
      message = '强'
      break
    default:
      message = '弱'
  }
  
  return { strength, message, suggestions }
}

/**
 * 生成唯一ID
 * @returns {string} 唯一ID
 */
export const generateUniqueId = () => {
  return Date.now().toString(36) + Math.random().toString(36).substr(2)
}

/**
 * 防抖函数
 * @param {Function} func - 要执行的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export const debounce = (func, wait) => {
  let timeout
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout)
      func(...args)
    }
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
  }
}

/**
 * 节流函数
 * @param {Function} func - 要执行的函数
 * @param {number} limit - 时间限制（毫秒）
 * @returns {Function} 节流后的函数
 */
export const throttle = (func, limit) => {
  let inThrottle
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args)
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
}

/**
 * 深拷贝
 * @param {*} obj - 要拷贝的对象
 * @returns {*} 拷贝后的对象
 */
export const deepClone = (obj) => {
  if (obj === null || typeof obj !== 'object') return obj
  if (obj instanceof Date) return new Date(obj.getTime())
  if (obj instanceof Array) return obj.map(item => deepClone(item))
  if (typeof obj === 'object') {
    const clonedObj = {}
    for (let key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key])
      }
    }
    return clonedObj
  }
}

/**
 * 获取URL参数
 * @param {string} name - 参数名
 * @returns {string|null} 参数值
 */
export const getQueryParam = (name) => {
  const urlParams = new URLSearchParams(window.location.search)
  return urlParams.get(name)
}

/**
 * 截取字符串
 * @param {string} str - 字符串
 * @param {number} length - 长度
 * @returns {string} 截取后的字符串
 */
export const truncate = (str, length = 10) => {
  if (!str || str.length <= length) return str
  return str.substring(0, length) + '...'
}

/**
 * 获取文件扩展名
 * @param {string} filename - 文件名
 * @returns {string} 扩展名
 */
export const getFileExtension = (filename) => {
  return filename.slice((filename.lastIndexOf('.') - 1 >>> 0) + 2)
}

/**
 * 检查文件类型是否为图片
 * @param {string} filename - 文件名
 * @returns {boolean} 是否为图片
 */
export const isImage = (filename) => {
  const imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp', 'svg']
  const extension = getFileExtension(filename).toLowerCase()
  return imageExtensions.includes(extension)
}

/**
 * 检查是否为管理员
 * @param {Object} user - 用户对象
 * @returns {boolean} 是否为管理员
 */
export const isAdmin = (user) => {
  return user && user.role === 'admin'
}

/**
 * 检查是否为卖家
 * @param {Object} user - 用户对象
 * @returns {boolean} 是否为卖家
 */
export const isSeller = (user) => {
  return user && (user.role === 'seller' || user.role === 'admin')
}

/**
 * 处理错误消息
 * @param {Error} error - 错误对象
 * @returns {string} 错误消息
 */
export const handleErrorMessage = (error) => {
  if (!error) return '未知错误'
  
  if (error.response) {
    return error.response.data?.message || '服务器错误'
  } else if (error.request) {
    return '网络连接失败，请检查您的网络'
  } else {
    return error.message || '请求失败'
  }
}
